/*
 *
 *    Copyright (c) 2022 Project CHIP Authors
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *        http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */

// THIS FILE IS GENERATED BY ZAP

#include <stdint.h>

#pragma once

namespace chip {
namespace app {
namespace Clusters {

namespace PowerConfiguration {
} // namespace PowerConfiguration

namespace DeviceTemperatureConfiguration {
} // namespace DeviceTemperatureConfiguration

namespace Identify {

// Need to convert consumers to using the new enum classes, so we
// don't just have casts all over.
#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
// Enum for IdentifyEffectIdentifier
enum class IdentifyEffectIdentifier : uint8_t
{
    kBlink         = 0x00,
    kBreathe       = 0x01,
    kOkay          = 0x02,
    kChannelChange = 0x0B,
    kFinishEffect  = 0xFE,
    kStopEffect    = 0xFF,
};
#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
using IdentifyEffectIdentifier        = EmberAfIdentifyEffectIdentifier;
#endif

// Need to convert consumers to using the new enum classes, so we
// don't just have casts all over.
#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
// Enum for IdentifyEffectVariant
enum class IdentifyEffectVariant : uint8_t
{
    kDefault = 0x00,
};
#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
using IdentifyEffectVariant           = EmberAfIdentifyEffectVariant;
#endif

// Need to convert consumers to using the new enum classes, so we
// don't just have casts all over.
#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
// Enum for IdentifyIdentifyType
enum class IdentifyIdentifyType : uint8_t
{
    kNone         = 0x00,
    kVisibleLight = 0x01,
    kVisibleLED   = 0x02,
    kAudibleBeep  = 0x03,
    kDisplay      = 0x04,
    kActuator     = 0x05,
};
#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
using IdentifyIdentifyType            = EmberAfIdentifyIdentifyType;
#endif
} // namespace Identify

namespace Groups {
} // namespace Groups

namespace Scenes {

// Bitmap for ScenesCopyMode
enum class ScenesCopyMode : uint8_t
{
    kCopyAllScenes = 0x1,
};
} // namespace Scenes

namespace OnOff {

// Need to convert consumers to using the new enum classes, so we
// don't just have casts all over.
#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
// Enum for OnOffDelayedAllOffEffectVariant
enum class OnOffDelayedAllOffEffectVariant : uint8_t
{
    kFadeToOffIn0p8Seconds                                = 0x00,
    kNoFade                                               = 0x01,
    k50PercentDimDownIn0p8SecondsThenFadeToOffIn12Seconds = 0x02,
};
#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
using OnOffDelayedAllOffEffectVariant = EmberAfOnOffDelayedAllOffEffectVariant;
#endif

// Need to convert consumers to using the new enum classes, so we
// don't just have casts all over.
#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
// Enum for OnOffDyingLightEffectVariant
enum class OnOffDyingLightEffectVariant : uint8_t
{
    k20PercenterDimUpIn0p5SecondsThenFadeToOffIn1Second = 0x00,
};
#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
using OnOffDyingLightEffectVariant    = EmberAfOnOffDyingLightEffectVariant;
#endif

// Need to convert consumers to using the new enum classes, so we
// don't just have casts all over.
#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
// Enum for OnOffEffectIdentifier
enum class OnOffEffectIdentifier : uint8_t
{
    kDelayedAllOff = 0x00,
    kDyingLight    = 0x01,
};
#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
using OnOffEffectIdentifier           = EmberAfOnOffEffectIdentifier;
#endif

// Bitmap for OnOffControl
enum class OnOffControl : uint8_t
{
    kAcceptOnlyWhenOn = 0x1,
};

// Bitmap for OnOffFeature
enum class OnOffFeature : uint32_t
{
    kLighting = 0x1,
};
} // namespace OnOff

namespace OnOffSwitchConfiguration {
} // namespace OnOffSwitchConfiguration

namespace LevelControl {

// Need to convert consumers to using the new enum classes, so we
// don't just have casts all over.
#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
// Enum for MoveMode
enum class MoveMode : uint8_t
{
    kUp   = 0x00,
    kDown = 0x01,
};
#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
using MoveMode                        = EmberAfMoveMode;
#endif

// Need to convert consumers to using the new enum classes, so we
// don't just have casts all over.
#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
// Enum for StepMode
enum class StepMode : uint8_t
{
    kUp   = 0x00,
    kDown = 0x01,
};
#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
using StepMode                        = EmberAfStepMode;
#endif

// Bitmap for LevelControlFeature
enum class LevelControlFeature : uint32_t
{
    kOnOff     = 0x1,
    kLighting  = 0x2,
    kFrequency = 0x4,
};
} // namespace LevelControl

namespace Alarms {
} // namespace Alarms

namespace Time {
} // namespace Time

namespace BinaryInputBasic {
} // namespace BinaryInputBasic

namespace PowerProfile {
} // namespace PowerProfile

namespace ApplianceControl {

// Enum for ApplianceStatus
enum class ApplianceStatus : uint8_t
{
    kOff                      = 0x01,
    kStandBy                  = 0x02,
    kProgrammed               = 0x03,
    kProgrammedWaitingToStart = 0x04,
    kRunning                  = 0x05,
    kPause                    = 0x06,
    kEndProgrammed            = 0x07,
    kFailure                  = 0x08,
    kProgrammeInterrupted     = 0x09,
    kIdle                     = 0x0A,
    kRinseHold                = 0x0B,
    kService                  = 0x0C,
    kSuperfreezing            = 0x0D,
    kSupercooling             = 0x0E,
    kSuperheating             = 0x0F,
};

// Enum for CommandIdentification
enum class CommandIdentification : uint8_t
{
    kStart                = 0x01,
    kStop                 = 0x02,
    kPause                = 0x03,
    kStartSuperfreezing   = 0x04,
    kStopSuperfreezing    = 0x05,
    kStartSupercooling    = 0x06,
    kStopSupercooling     = 0x07,
    kDisableGas           = 0x08,
    kEnableGas            = 0x09,
    kEnableEnergyControl  = 0x0A,
    kDisableEnergyControl = 0x0B,
};

// Enum for WarningEvent
enum class WarningEvent : uint8_t
{
    kWarning1OverallPowerAboveAvailablePowerLevel                                      = 0x00,
    kWarning2OverallPowerAbovePowerThresholdLevel                                      = 0x01,
    kWarning3OverallPowerBackBelowTheAvailablePowerLevel                               = 0x02,
    kWarning4OverallPowerBackBelowThePowerThresholdLevel                               = 0x03,
    kWarning5OverallPowerWillBePotentiallyAboveAvailablePowerLevelIfTheApplianceStarts = 0x04,
};

// Bitmap for RemoteEnableFlagsAndDeviceStatus2
enum class RemoteEnableFlagsAndDeviceStatus2 : uint8_t
{
    kRemoteEnableFlags      = 0xF,
    kDeviceStatus2Structure = 0xF0,
};
} // namespace ApplianceControl

namespace PulseWidthModulation {
} // namespace PulseWidthModulation

namespace Descriptor {
} // namespace Descriptor

namespace Binding {
} // namespace Binding

namespace AccessControl {

// Enum for AuthMode
enum class AuthMode : uint8_t
{
    kPase  = 0x01,
    kCase  = 0x02,
    kGroup = 0x03,
};

// Enum for ChangeTypeEnum
enum class ChangeTypeEnum : uint8_t
{
    kChanged = 0x00,
    kAdded   = 0x01,
    kRemoved = 0x02,
};

// Enum for Privilege
enum class Privilege : uint8_t
{
    kView       = 0x01,
    kProxyView  = 0x02,
    kOperate    = 0x03,
    kManage     = 0x04,
    kAdminister = 0x05,
};
} // namespace AccessControl

namespace PollControl {
} // namespace PollControl

namespace BridgedActions {

// Enum for ActionErrorEnum
enum class ActionErrorEnum : uint8_t
{
    kUnknown     = 0x00,
    kInterrupted = 0x01,
};

// Enum for ActionStateEnum
enum class ActionStateEnum : uint8_t
{
    kInactive = 0x00,
    kActive   = 0x01,
    kPaused   = 0x02,
    kDisabled = 0x03,
};

// Enum for ActionTypeEnum
enum class ActionTypeEnum : uint8_t
{
    kOther        = 0x00,
    kScene        = 0x01,
    kSequence     = 0x02,
    kAutomation   = 0x03,
    kException    = 0x04,
    kNotification = 0x05,
    kAlarm        = 0x06,
};

// Enum for EndpointListTypeEnum
enum class EndpointListTypeEnum : uint8_t
{
    kOther = 0x00,
    kRoom  = 0x01,
    kZone  = 0x02,
};

// Bitmap for CommandBits
enum class CommandBits : uint16_t
{
    kInstantAction               = 0x1,
    kInstantActionWithTransition = 0x2,
    kStartAction                 = 0x4,
    kStartActionWithDuration     = 0x8,
    kStopAction                  = 0x10,
    kPauseAction                 = 0x20,
    kPauseActionWithDuration     = 0x40,
    kResumeAction                = 0x80,
    kEnableAction                = 0x100,
    kEnableActionWithDuration    = 0x200,
    kDisableAction               = 0x400,
    kDisableActionWithDuration   = 0x800,
};
} // namespace BridgedActions

namespace Basic {
} // namespace Basic

namespace OtaSoftwareUpdateProvider {

// Enum for OTAApplyUpdateAction
enum class OTAApplyUpdateAction : uint8_t
{
    kProceed         = 0x00,
    kAwaitNextAction = 0x01,
    kDiscontinue     = 0x02,
};

// Enum for OTADownloadProtocol
enum class OTADownloadProtocol : uint8_t
{
    kBDXSynchronous  = 0x00,
    kBDXAsynchronous = 0x01,
    kHttps           = 0x02,
    kVendorSpecific  = 0x03,
};

// Enum for OTAQueryStatus
enum class OTAQueryStatus : uint8_t
{
    kUpdateAvailable              = 0x00,
    kBusy                         = 0x01,
    kNotAvailable                 = 0x02,
    kDownloadProtocolNotSupported = 0x03,
};
} // namespace OtaSoftwareUpdateProvider

namespace OtaSoftwareUpdateRequestor {

// Enum for OTAAnnouncementReason
enum class OTAAnnouncementReason : uint8_t
{
    kSimpleAnnouncement    = 0x00,
    kUpdateAvailable       = 0x01,
    kUrgentUpdateAvailable = 0x02,
};

// Enum for OTAChangeReasonEnum
enum class OTAChangeReasonEnum : uint8_t
{
    kUnknown         = 0x00,
    kSuccess         = 0x01,
    kFailure         = 0x02,
    kTimeOut         = 0x03,
    kDelayByProvider = 0x04,
};

// Enum for OTAUpdateStateEnum
enum class OTAUpdateStateEnum : uint8_t
{
    kUnknown              = 0x00,
    kIdle                 = 0x01,
    kQuerying             = 0x02,
    kDelayedOnQuery       = 0x03,
    kDownloading          = 0x04,
    kApplying             = 0x05,
    kDelayedOnApply       = 0x06,
    kRollingBack          = 0x07,
    kDelayedOnUserConsent = 0x08,
};
} // namespace OtaSoftwareUpdateRequestor

namespace LocalizationConfiguration {
} // namespace LocalizationConfiguration

namespace TimeFormatLocalization {

// Enum for CalendarType
enum class CalendarType : uint8_t
{
    kBuddhist  = 0x00,
    kChinese   = 0x01,
    kCoptic    = 0x02,
    kEthiopian = 0x03,
    kGregorian = 0x04,
    kHebrew    = 0x05,
    kIndian    = 0x06,
    kIslamic   = 0x07,
    kJapanese  = 0x08,
    kKorean    = 0x09,
    kPersian   = 0x0A,
    kTaiwanese = 0x0B,
};

// Enum for HourFormat
enum class HourFormat : uint8_t
{
    k12hr = 0x00,
    k24hr = 0x01,
};
} // namespace TimeFormatLocalization

namespace UnitLocalization {

// Enum for TempUnit
enum class TempUnit : uint8_t
{
    kFahrenheit = 0x00,
    kCelsius    = 0x01,
    kKelvin     = 0x02,
};

// Bitmap for UnitLocalizationFeature
enum class UnitLocalizationFeature : uint32_t
{
    kTemperatureUnit = 0x1,
};
} // namespace UnitLocalization

namespace PowerSourceConfiguration {
} // namespace PowerSourceConfiguration

namespace PowerSource {

// Enum for BatChargeFaultType
enum class BatChargeFaultType : uint8_t
{
    kUnspecfied          = 0x00,
    kAmbientTooHot       = 0x01,
    kAmbientTooCold      = 0x02,
    kBatteryTooHot       = 0x03,
    kBatteryTooCold      = 0x04,
    kBatteryAbsent       = 0x05,
    kBatteryOverVoltage  = 0x06,
    kBatteryUnderVoltage = 0x07,
    kChargerOverVoltage  = 0x08,
    kChargerUnderVoltage = 0x09,
    kSafetyTimeout       = 0x0A,
};

// Enum for BatChargeLevel
enum class BatChargeLevel : uint8_t
{
    kOk       = 0x00,
    kWarning  = 0x01,
    kCritical = 0x02,
};

// Enum for BatChargeState
enum class BatChargeState : uint8_t
{
    kUnknown        = 0x00,
    kIsCharging     = 0x01,
    kIsAtFullCharge = 0x02,
    kIsNotCharging  = 0x03,
};

// Enum for BatFaultType
enum class BatFaultType : uint8_t
{
    kUnspecfied = 0x00,
    kOverTemp   = 0x01,
    kUnderTemp  = 0x02,
};

// Enum for BatReplaceability
enum class BatReplaceability : uint8_t
{
    kUnspecified        = 0x00,
    kNotReplaceable     = 0x01,
    kUserReplaceable    = 0x02,
    kFactoryReplaceable = 0x03,
};

// Enum for PowerSourceStatus
enum class PowerSourceStatus : uint8_t
{
    kUnspecfied  = 0x00,
    kActive      = 0x01,
    kStandby     = 0x02,
    kUnavailable = 0x03,
};

// Enum for WiredCurrentType
enum class WiredCurrentType : uint8_t
{
    kAc = 0x00,
    kDc = 0x01,
};

// Enum for WiredFaultType
enum class WiredFaultType : uint8_t
{
    kUnspecfied   = 0x00,
    kOverVoltage  = 0x01,
    kUnderVoltage = 0x02,
};

// Bitmap for PowerSourceFeature
enum class PowerSourceFeature : uint32_t
{
    kWired        = 0x1,
    kBattery      = 0x2,
    kRechargeable = 0x4,
    kReplaceable  = 0x8,
};
} // namespace PowerSource

namespace GeneralCommissioning {

// Enum for CommissioningError
enum class CommissioningError : uint8_t
{
    kOk                    = 0x00,
    kValueOutsideRange     = 0x01,
    kInvalidAuthentication = 0x02,
    kNoFailSafe            = 0x03,
    kBusyWithOtherAdmin    = 0x04,
};

// Enum for RegulatoryLocationType
enum class RegulatoryLocationType : uint8_t
{
    kIndoor        = 0x00,
    kOutdoor       = 0x01,
    kIndoorOutdoor = 0x02,
};
} // namespace GeneralCommissioning

namespace NetworkCommissioning {

// Enum for NetworkCommissioningStatus
enum class NetworkCommissioningStatus : uint8_t
{
    kSuccess                = 0x00,
    kOutOfRange             = 0x01,
    kBoundsExceeded         = 0x02,
    kNetworkIDNotFound      = 0x03,
    kDuplicateNetworkID     = 0x04,
    kNetworkNotFound        = 0x05,
    kRegulatoryError        = 0x06,
    kAuthFailure            = 0x07,
    kUnsupportedSecurity    = 0x08,
    kOtherConnectionFailure = 0x09,
    kIPV6Failed             = 0x0A,
    kIPBindFailed           = 0x0B,
    kUnknownError           = 0x0C,
};

// Enum for WiFiBand
enum class WiFiBand : uint8_t
{
    k2g4  = 0x00,
    k3g65 = 0x01,
    k5g   = 0x02,
    k6g   = 0x03,
    k60g  = 0x04,
};

// Bitmap for NetworkCommissioningFeature
enum class NetworkCommissioningFeature : uint32_t
{
    kWiFiNetworkInterface     = 0x1,
    kThreadNetworkInterface   = 0x2,
    kEthernetNetworkInterface = 0x4,
};
} // namespace NetworkCommissioning

namespace DiagnosticLogs {

// Enum for LogsIntent
enum class LogsIntent : uint8_t
{
    kEndUserSupport = 0x00,
    kNetworkDiag    = 0x01,
    kCrashLogs      = 0x02,
};

// Enum for LogsStatus
enum class LogsStatus : uint8_t
{
    kSuccess   = 0x00,
    kExhausted = 0x01,
    kNoLogs    = 0x02,
    kBusy      = 0x03,
    kDenied    = 0x04,
};

// Enum for LogsTransferProtocol
enum class LogsTransferProtocol : uint8_t
{
    kResponsePayload = 0x00,
    kBdx             = 0x01,
};
} // namespace DiagnosticLogs

namespace GeneralDiagnostics {

// Need to convert consumers to using the new enum classes, so we
// don't just have casts all over.
#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
// Enum for BootReasonType
enum class BootReasonType : uint8_t
{
    kUnspecified             = 0x00,
    kPowerOnReboot           = 0x01,
    kBrownOutReset           = 0x02,
    kSoftwareWatchdogReset   = 0x03,
    kHardwareWatchdogReset   = 0x04,
    kSoftwareUpdateCompleted = 0x05,
    kSoftwareReset           = 0x06,
};
#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
using BootReasonType                  = EmberAfBootReasonType;
#endif

// Need to convert consumers to using the new enum classes, so we
// don't just have casts all over.
#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
// Enum for HardwareFaultType
enum class HardwareFaultType : uint8_t
{
    kUnspecified            = 0x00,
    kRadio                  = 0x01,
    kSensor                 = 0x02,
    kResettableOverTemp     = 0x03,
    kNonResettableOverTemp  = 0x04,
    kPowerSource            = 0x05,
    kVisualDisplayFault     = 0x06,
    kAudioOutputFault       = 0x07,
    kUserInterfaceFault     = 0x08,
    kNonVolatileMemoryError = 0x09,
    kTamperDetected         = 0x0A,
};
#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
using HardwareFaultType               = EmberAfHardwareFaultType;
#endif

// Need to convert consumers to using the new enum classes, so we
// don't just have casts all over.
#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
// Enum for InterfaceType
enum class InterfaceType : uint8_t
{
    kUnspecified = 0x00,
    kWiFi        = 0x01,
    kEthernet    = 0x02,
    kCellular    = 0x03,
    kThread      = 0x04,
};
#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
using InterfaceType                   = EmberAfInterfaceType;
#endif

// Need to convert consumers to using the new enum classes, so we
// don't just have casts all over.
#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
// Enum for NetworkFaultType
enum class NetworkFaultType : uint8_t
{
    kUnspecified      = 0x00,
    kHardwareFailure  = 0x01,
    kNetworkJammed    = 0x02,
    kConnectionFailed = 0x03,
};
#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
using NetworkFaultType                = EmberAfNetworkFaultType;
#endif

// Need to convert consumers to using the new enum classes, so we
// don't just have casts all over.
#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
// Enum for RadioFaultType
enum class RadioFaultType : uint8_t
{
    kUnspecified   = 0x00,
    kWiFiFault     = 0x01,
    kCellularFault = 0x02,
    kThreadFault   = 0x03,
    kNFCFault      = 0x04,
    kBLEFault      = 0x05,
    kEthernetFault = 0x06,
};
#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
using RadioFaultType                  = EmberAfRadioFaultType;
#endif
} // namespace GeneralDiagnostics

namespace SoftwareDiagnostics {
} // namespace SoftwareDiagnostics

namespace ThreadNetworkDiagnostics {

// Enum for NetworkFault
enum class NetworkFault : uint8_t
{
    kUnspecified     = 0x00,
    kLinkDown        = 0x01,
    kHardwareFailure = 0x02,
    kNetworkJammed   = 0x03,
};

// Need to convert consumers to using the new enum classes, so we
// don't just have casts all over.
#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
// Enum for RoutingRole
enum class RoutingRole : uint8_t
{
    kUnspecified     = 0x00,
    kUnassigned      = 0x01,
    kSleepyEndDevice = 0x02,
    kEndDevice       = 0x03,
    kReed            = 0x04,
    kRouter          = 0x05,
    kLeader          = 0x06,
};
#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
using RoutingRole                     = EmberAfRoutingRole;
#endif

// Enum for ThreadConnectionStatus
enum class ThreadConnectionStatus : uint8_t
{
    kConnected    = 0x00,
    kNotConnected = 0x01,
};

// Bitmap for ThreadNetworkDiagnosticsFeature
enum class ThreadNetworkDiagnosticsFeature : uint32_t
{
    kPacketCounts = 0x1,
    kErrorCounts  = 0x2,
    kMLECounts    = 0x4,
    kMACCounts    = 0x8,
};
} // namespace ThreadNetworkDiagnostics

namespace WiFiNetworkDiagnostics {

// Enum for AssociationFailureCause
enum class AssociationFailureCause : uint8_t
{
    kUnknown              = 0x00,
    kAssociationFailed    = 0x01,
    kAuthenticationFailed = 0x02,
    kSsidNotFound         = 0x03,
};

// Need to convert consumers to using the new enum classes, so we
// don't just have casts all over.
#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
// Enum for SecurityType
enum class SecurityType : uint8_t
{
    kUnspecified = 0x00,
    kNone        = 0x01,
    kWep         = 0x02,
    kWpa         = 0x03,
    kWpa2        = 0x04,
    kWpa3        = 0x05,
};
#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
using SecurityType                    = EmberAfSecurityType;
#endif

// Enum for WiFiConnectionStatus
enum class WiFiConnectionStatus : uint8_t
{
    kConnected    = 0x00,
    kNotConnected = 0x01,
};

// Need to convert consumers to using the new enum classes, so we
// don't just have casts all over.
#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
// Enum for WiFiVersionType
enum class WiFiVersionType : uint8_t
{
    k80211a  = 0x00,
    k80211b  = 0x01,
    k80211g  = 0x02,
    k80211n  = 0x03,
    k80211ac = 0x04,
    k80211ax = 0x05,
};
#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
using WiFiVersionType                 = EmberAfWiFiVersionType;
#endif
} // namespace WiFiNetworkDiagnostics

namespace EthernetNetworkDiagnostics {

// Need to convert consumers to using the new enum classes, so we
// don't just have casts all over.
#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
// Enum for PHYRateType
enum class PHYRateType : uint8_t
{
    k10m   = 0x00,
    k100m  = 0x01,
    k1000m = 0x02,
    k25g   = 0x03,
    k5g    = 0x04,
    k10g   = 0x05,
    k40g   = 0x06,
    k100g  = 0x07,
    k200g  = 0x08,
    k400g  = 0x09,
};
#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
using PHYRateType                     = EmberAfPHYRateType;
#endif
} // namespace EthernetNetworkDiagnostics

namespace TimeSynchronization {
} // namespace TimeSynchronization

namespace BridgedDeviceBasic {
} // namespace BridgedDeviceBasic

namespace Switch {
} // namespace Switch

namespace AdministratorCommissioning {

// Enum for CommissioningWindowStatus
enum class CommissioningWindowStatus : uint8_t
{
    kWindowNotOpen      = 0x00,
    kEnhancedWindowOpen = 0x01,
    kBasicWindowOpen    = 0x02,
};

// Need to convert consumers to using the new enum classes, so we
// don't just have casts all over.
#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
// Enum for StatusCode
enum class StatusCode : uint8_t
{
    kBusy               = 0x01,
    kPAKEParameterError = 0x02,
    kWindowNotOpen      = 0x03,
};
#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
using StatusCode                      = EmberAfStatusCode;
#endif
} // namespace AdministratorCommissioning

namespace OperationalCredentials {

// Enum for OperationalCertStatus
enum class OperationalCertStatus : uint8_t
{
    kSuccess               = 0x00,
    kInvalidPublicKey      = 0x01,
    kInvalidNodeOpId       = 0x02,
    kInvalidNOC            = 0x03,
    kMissingCsr            = 0x04,
    kTableFull             = 0x05,
    kInsufficientPrivilege = 0x08,
    kFabricConflict        = 0x09,
    kLabelConflict         = 0x0A,
    kInvalidFabricIndex    = 0x0B,
};
} // namespace OperationalCredentials

namespace GroupKeyManagement {

// Enum for GroupKeySecurityPolicy
enum class GroupKeySecurityPolicy : uint8_t
{
    kTrustFirst   = 0x00,
    kCacheAndSync = 0x01,
};
} // namespace GroupKeyManagement

namespace FixedLabel {
} // namespace FixedLabel

namespace UserLabel {
} // namespace UserLabel

namespace ProxyConfiguration {
} // namespace ProxyConfiguration

namespace ProxyDiscovery {
} // namespace ProxyDiscovery

namespace ProxyValid {
} // namespace ProxyValid

namespace BooleanState {
} // namespace BooleanState

namespace ModeSelect {
} // namespace ModeSelect

namespace ShadeConfiguration {
} // namespace ShadeConfiguration

namespace DoorLock {

// Enum for DlAlarmCode
enum class DlAlarmCode : uint8_t
{
    kLockJammed              = 0x00,
    kLockFactoryReset        = 0x01,
    kLockRadioPowerCycled    = 0x03,
    kWrongCodeEntryLimit     = 0x04,
    kFrontEsceutcheonRemoved = 0x05,
    kDoorForcedOpen          = 0x06,
    kDoorAjar                = 0x07,
    kForcedUser              = 0x08,
};

// Enum for DlCredentialRule
enum class DlCredentialRule : uint8_t
{
    kSingle = 0x00,
    kDouble = 0x01,
    kTri    = 0x02,
};

// Enum for DlCredentialType
enum class DlCredentialType : uint8_t
{
    kProgrammingPIN = 0x00,
    kPin            = 0x01,
    kRfid           = 0x02,
    kFingerprint    = 0x03,
    kFingerVein     = 0x04,
    kFace           = 0x05,
};

// Enum for DlDataOperationType
enum class DlDataOperationType : uint8_t
{
    kAdd    = 0x00,
    kClear  = 0x01,
    kModify = 0x02,
};

// Enum for DlDoorState
enum class DlDoorState : uint8_t
{
    kDoorOpen             = 0x00,
    kDoorClosed           = 0x01,
    kDoorJammed           = 0x02,
    kDoorForcedOpen       = 0x03,
    kDoorUnspecifiedError = 0x04,
    kDoorAjar             = 0x05,
};

// Enum for DlLockDataType
enum class DlLockDataType : uint8_t
{
    kUnspecified     = 0x00,
    kProgrammingCode = 0x01,
    kUserIndex       = 0x02,
    kWeekDaySchedule = 0x03,
    kYearDaySchedule = 0x04,
    kHolidaySchedule = 0x05,
    kPin             = 0x06,
    kRfid            = 0x07,
    kFingerprint     = 0x08,
};

// Enum for DlLockOperationType
enum class DlLockOperationType : uint8_t
{
    kLock               = 0x00,
    kUnlock             = 0x01,
    kNonAccessUserEvent = 0x02,
    kForcedUserEvent    = 0x03,
};

// Enum for DlLockState
enum class DlLockState : uint8_t
{
    kNotFullyLocked = 0x00,
    kLocked         = 0x01,
    kUnlocked       = 0x02,
};

// Enum for DlLockType
enum class DlLockType : uint8_t
{
    kDeadBolt           = 0x00,
    kMagnetic           = 0x01,
    kOther              = 0x02,
    kMortise            = 0x03,
    kRim                = 0x04,
    kLatchBolt          = 0x05,
    kCylindricalLock    = 0x06,
    kTubularLock        = 0x07,
    kInterconnectedLock = 0x08,
    kDeadLatch          = 0x09,
    kDoorFurniture      = 0x0A,
};

// Enum for DlOperatingMode
enum class DlOperatingMode : uint8_t
{
    kNormal             = 0x00,
    kVacation           = 0x01,
    kPrivacy            = 0x02,
    kNoRemoteLockUnlock = 0x03,
    kPassage            = 0x04,
};

// Enum for DlOperationError
enum class DlOperationError : uint8_t
{
    kUnspecified         = 0x00,
    kInvalidCredential   = 0x01,
    kDisabledUserDenied  = 0x02,
    kRestricted          = 0x03,
    kInsufficientBattery = 0x04,
};

// Enum for DlOperationSource
enum class DlOperationSource : uint8_t
{
    kUnspecified       = 0x00,
    kManual            = 0x01,
    kProprietaryRemote = 0x02,
    kKeypad            = 0x03,
    kAuto              = 0x04,
    kButton            = 0x05,
    kSchedule          = 0x06,
    kRemote            = 0x07,
    kRfid              = 0x08,
    kBiometric         = 0x09,
};

// Enum for DlStatus
enum class DlStatus : uint8_t
{
    kSuccess      = 0x00,
    kFailure      = 0x01,
    kDuplicate    = 0x02,
    kOccupied     = 0x03,
    kInvalidField = 0x85,
    kNotFound     = 0x8B,
};

// Enum for DlUserStatus
enum class DlUserStatus : uint8_t
{
    kAvailable        = 0x00,
    kOccupiedEnabled  = 0x01,
    kOccupiedDisabled = 0x03,
};

// Enum for DlUserType
enum class DlUserType : uint8_t
{
    kUnrestrictedUser       = 0x00,
    kYearDayScheduleUser    = 0x01,
    kWeekDayScheduleUser    = 0x02,
    kProgrammingUser        = 0x03,
    kNonAccessUser          = 0x04,
    kForcedUser             = 0x05,
    kDisposableUser         = 0x06,
    kExpiringUser           = 0x07,
    kScheduleRestrictedUser = 0x08,
    kRemoteOnlyUser         = 0x09,
};

// Enum for DoorLockOperationEventCode
enum class DoorLockOperationEventCode : uint8_t
{
    kUnknownOrMfgSpecific  = 0x00,
    kLock                  = 0x01,
    kUnlock                = 0x02,
    kLockInvalidPinOrId    = 0x03,
    kLockInvalidSchedule   = 0x04,
    kUnlockInvalidPinOrId  = 0x05,
    kUnlockInvalidSchedule = 0x06,
    kOneTouchLock          = 0x07,
    kKeyLock               = 0x08,
    kKeyUnlock             = 0x09,
    kAutoLock              = 0x0A,
    kScheduleLock          = 0x0B,
    kScheduleUnlock        = 0x0C,
    kManualLock            = 0x0D,
    kManualUnlock          = 0x0E,
};

// Enum for DoorLockProgrammingEventCode
enum class DoorLockProgrammingEventCode : uint8_t
{
    kUnknownOrMfgSpecific = 0x00,
    kMasterCodeChanged    = 0x01,
    kPinAdded             = 0x02,
    kPinDeleted           = 0x03,
    kPinChanged           = 0x04,
    kIdAdded              = 0x05,
    kIdDeleted            = 0x06,
};

// Enum for DoorLockSetPinOrIdStatus
enum class DoorLockSetPinOrIdStatus : uint8_t
{
    kSuccess            = 0x00,
    kGeneralFailure     = 0x01,
    kMemoryFull         = 0x02,
    kDuplicateCodeError = 0x03,
};

// Enum for DoorLockUserStatus
enum class DoorLockUserStatus : uint8_t
{
    kAvailable        = 0x00,
    kOccupiedEnabled  = 0x01,
    kOccupiedDisabled = 0x03,
    kNotSupported     = 0xFF,
};

// Enum for DoorLockUserType
enum class DoorLockUserType : uint8_t
{
    kUnrestricted        = 0x00,
    kYearDayScheduleUser = 0x01,
    kWeekDayScheduleUser = 0x02,
    kMasterUser          = 0x03,
    kNonAccessUser       = 0x04,
    kNotSupported        = 0xFF,
};

// Bitmap for DlAlarmMask
enum class DlAlarmMask : uint16_t
{
    kLockingMechanismJammed                 = 0x1,
    kLockResetToFactoryDefaults             = 0x2,
    kReserved                               = 0x4,
    kRFModulePowerCycled                    = 0x8,
    kWrongCodeEntryLimit                    = 0x10,
    kFrontEscutcheonRemovedFromMain         = 0x20,
    kForcedDoorOpenUnderDoorLockedCondition = 0x40,
};

// Bitmap for DlCredentialRuleMask
enum class DlCredentialRuleMask : uint8_t
{
    kSingle = 0x1,
    kDual   = 0x2,
    kTri    = 0x4,
};

// Bitmap for DlCredentialRulesSupport
enum class DlCredentialRulesSupport : uint8_t
{
    kSingle = 0x1,
    kDual   = 0x2,
    kTri    = 0x4,
};

// Bitmap for DlDaysMaskMap
enum class DlDaysMaskMap : uint8_t
{
    kSunday    = 0x1,
    kMonday    = 0x2,
    kTuesday   = 0x4,
    kWednesday = 0x8,
    kThursday  = 0x10,
    kFriday    = 0x20,
    kSaturday  = 0x40,
};

// Bitmap for DlDefaultConfigurationRegister
enum class DlDefaultConfigurationRegister : uint16_t
{
    kEnableLocalProgrammingEnabled         = 0x1,
    kKeypadInterfaceDefaultAccessEnabled   = 0x2,
    kRemoteInterfaceDefaultAccessIsEnabled = 0x4,
    kSoundEnabled                          = 0x20,
    kAutoRelockTimeSet                     = 0x40,
    kLEDSettingsSet                        = 0x80,
};

// Bitmap for DlKeypadOperationEventMask
enum class DlKeypadOperationEventMask : uint16_t
{
    kUnknown               = 0x1,
    kLock                  = 0x2,
    kUnlock                = 0x4,
    kLockInvalidPIN        = 0x8,
    kLockInvalidSchedule   = 0x10,
    kUnlockInvalidCode     = 0x20,
    kUnlockInvalidSchedule = 0x40,
    kNonAccessUserOpEvent  = 0x80,
};

// Bitmap for DlKeypadProgrammingEventMask
enum class DlKeypadProgrammingEventMask : uint16_t
{
    kUnknown               = 0x1,
    kProgrammingPINChanged = 0x2,
    kPINAdded              = 0x4,
    kPINCleared            = 0x8,
    kPINChanged            = 0x10,
};

// Bitmap for DlLocalProgrammingFeatures
enum class DlLocalProgrammingFeatures : uint8_t
{
    kAddUsersCredentialsSchedulesLocally    = 0x1,
    kModifyUsersCredentialsSchedulesLocally = 0x2,
    kClearUsersCredentialsSchedulesLocally  = 0x4,
    kAdjustLockSettingsLocally              = 0x8,
};

// Bitmap for DlManualOperationEventMask
enum class DlManualOperationEventMask : uint16_t
{
    kUnknown         = 0x1,
    kThumbturnLock   = 0x2,
    kThumbturnUnlock = 0x4,
    kOneTouchLock    = 0x8,
    kKeyLock         = 0x10,
    kKeyUnlock       = 0x20,
    kAutoLock        = 0x40,
    kScheduleLock    = 0x80,
    kScheduleUnlock  = 0x100,
    kManualLock      = 0x200,
    kManualUnlock    = 0x400,
};

// Bitmap for DlRFIDOperationEventMask
enum class DlRFIDOperationEventMask : uint16_t
{
    kUnknown               = 0x1,
    kLock                  = 0x2,
    kUnlock                = 0x4,
    kLockInvalidRFID       = 0x8,
    kLockInvalidSchedule   = 0x10,
    kUnlockInvalidRFID     = 0x20,
    kUnlockInvalidSchedule = 0x40,
};

// Bitmap for DlRFIDProgrammingEventMask
enum class DlRFIDProgrammingEventMask : uint16_t
{
    kUnknown         = 0x1,
    kRFIDCodeAdded   = 0x20,
    kRFIDCodeCleared = 0x40,
};

// Bitmap for DlRemoteOperationEventMask
enum class DlRemoteOperationEventMask : uint16_t
{
    kUnknown               = 0x1,
    kLock                  = 0x2,
    kUnlock                = 0x4,
    kLockInvalidCode       = 0x8,
    kLockInvalidSchedule   = 0x10,
    kUnlockInvalidCode     = 0x20,
    kUnlockInvalidSchedule = 0x40,
};

// Bitmap for DlRemoteProgrammingEventMask
enum class DlRemoteProgrammingEventMask : uint16_t
{
    kUnknown               = 0x1,
    kProgrammingPINChanged = 0x2,
    kPINAdded              = 0x4,
    kPINCleared            = 0x8,
    kPINChanged            = 0x10,
    kRFIDCodeAdded         = 0x20,
    kRFIDCodeCleared       = 0x40,
};

// Bitmap for DlSupportedOperatingModes
enum class DlSupportedOperatingModes : uint16_t
{
    kNormal             = 0x1,
    kVacation           = 0x2,
    kPrivacy            = 0x4,
    kNoRemoteLockUnlock = 0x8,
    kPassage            = 0x10,
};

// Bitmap for DoorLockDayOfWeek
enum class DoorLockDayOfWeek : uint8_t
{
    kSunday    = 0x1,
    kMonday    = 0x2,
    kTuesday   = 0x4,
    kWednesday = 0x8,
    kThursday  = 0x10,
    kFriday    = 0x20,
    kSaturday  = 0x40,
};

// Bitmap for DoorLockFeature
enum class DoorLockFeature : uint32_t
{
    kPINCredentials     = 0x1,
    kRFIDCredentials    = 0x2,
    kFingerCredentials  = 0x4,
    kLogging            = 0x8,
    kAccessSchedules    = 0x10,
    kDoorPositionSensor = 0x20,
    kFaceCredentials    = 0x40,
    kCredentialsOTA     = 0x80,
    kUsersManagement    = 0x100,
    kNotifications      = 0x200,
};
} // namespace DoorLock

namespace WindowCovering {

// Bitmap for WcConfigStatus
enum class WcConfigStatus : uint8_t
{
    kOperational               = 0x1,
    kOnline                    = 0x2,
    kOpenAndUpCommandsReversed = 0x4,
    kLiftPositionAware         = 0x8,
    kTiltPositionAware         = 0x10,
    kLiftEncoderControlled     = 0x20,
    kTiltEncoderControlled     = 0x40,
};

// Bitmap for WcFeature
enum class WcFeature : uint32_t
{
    kLift              = 0x1,
    kTilt              = 0x2,
    kPositionAwareLift = 0x4,
    kAbsolutePosition  = 0x8,
    kPositionAwareTilt = 0x10,
};

// Bitmap for WcMode
enum class WcMode : uint8_t
{
    kMotorDirectionReversed = 0x1,
    kCalibrationMode        = 0x2,
    kMaintenanceMode        = 0x4,
    kLEDFeedback            = 0x8,
};

// Bitmap for WcOperationalStatus
enum class WcOperationalStatus : uint8_t
{
    kGlobal = 0x3,
    kLift   = 0xC,
    kTilt   = 0x30,
};

// Bitmap for WcSafetyStatus
enum class WcSafetyStatus : uint16_t
{
    kRemoteLockout       = 0x1,
    kTamperDetection     = 0x2,
    kFailedCommunication = 0x4,
    kPositionFailure     = 0x8,
    kThermalProtection   = 0x10,
    kObstacleDetected    = 0x20,
    kPower               = 0x40,
    kStopInput           = 0x80,
    kMotorJammed         = 0x100,
    kHardwareFailure     = 0x200,
    kManualOperation     = 0x400,
    kProtection          = 0x800,
};
} // namespace WindowCovering

namespace BarrierControl {
} // namespace BarrierControl

namespace PumpConfigurationAndControl {

// Enum for PumpControlMode
enum class PumpControlMode : uint8_t
{
    kConstantSpeed        = 0x00,
    kConstantPressure     = 0x01,
    kProportionalPressure = 0x02,
    kConstantFlow         = 0x03,
    kConstantTemperature  = 0x05,
    kAutomatic            = 0x07,
};

// Enum for PumpOperationMode
enum class PumpOperationMode : uint8_t
{
    kNormal  = 0x00,
    kMinimum = 0x01,
    kMaximum = 0x02,
    kLocal   = 0x03,
};

// Bitmap for PumpStatus
enum class PumpStatus : uint16_t
{
    kDeviceFault       = 0x1,
    kSupplyfault       = 0x2,
    kSpeedLow          = 0x4,
    kSpeedHigh         = 0x8,
    kLocalOverride     = 0x10,
    kRunning           = 0x20,
    kRemotePressure    = 0x40,
    kRemoteFlow        = 0x80,
    kRemoteTemperature = 0x100,
};
} // namespace PumpConfigurationAndControl

namespace Thermostat {

// Need to convert consumers to using the new enum classes, so we
// don't just have casts all over.
#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
// Enum for SetpointAdjustMode
enum class SetpointAdjustMode : uint8_t
{
    kHeatSetpoint         = 0x00,
    kCoolSetpoint         = 0x01,
    kHeatAndCoolSetpoints = 0x02,
};
#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
using SetpointAdjustMode              = EmberAfSetpointAdjustMode;
#endif

// Enum for ThermostatControlSequence
enum class ThermostatControlSequence : uint8_t
{
    kCoolingOnly                 = 0x00,
    kCoolingWithReheat           = 0x01,
    kHeatingOnly                 = 0x02,
    kHeatingWithReheat           = 0x03,
    kCoolingAndHeating           = 0x04,
    kCoolingAndHeatingWithReheat = 0x05,
};

// Enum for ThermostatRunningMode
enum class ThermostatRunningMode : uint8_t
{
    kOff  = 0x00,
    kCool = 0x03,
    kHeat = 0x04,
};

// Enum for ThermostatSystemMode
enum class ThermostatSystemMode : uint8_t
{
    kOff              = 0x00,
    kAuto             = 0x01,
    kCool             = 0x03,
    kHeat             = 0x04,
    kEmergencyHeating = 0x05,
    kPrecooling       = 0x06,
    kFanOnly          = 0x07,
};

// Bitmap for DayOfWeek
enum class DayOfWeek : uint8_t
{
    kSunday         = 0x1,
    kMonday         = 0x2,
    kTuesday        = 0x4,
    kWednesday      = 0x8,
    kThursday       = 0x10,
    kFriday         = 0x20,
    kSaturday       = 0x40,
    kAwayOrVacation = 0x80,
};

// Bitmap for ModeForSequence
enum class ModeForSequence : uint8_t
{
    kHeatSetpointFieldPresent = 0x1,
    kCoolSetpointFieldPresent = 0x2,
};

// Bitmap for ThermostatFeature
enum class ThermostatFeature : uint32_t
{
    kHeating   = 0x1,
    kCooling   = 0x2,
    kOccupancy = 0x4,
    kSchedule  = 0x8,
    kSetback   = 0x10,
    kAutomode  = 0x20,
};
} // namespace Thermostat

namespace FanControl {
} // namespace FanControl

namespace DehumidificationControl {
} // namespace DehumidificationControl

namespace ThermostatUserInterfaceConfiguration {
} // namespace ThermostatUserInterfaceConfiguration

namespace ColorControl {

// Need to convert consumers to using the new enum classes, so we
// don't just have casts all over.
#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
// Enum for ColorLoopAction
enum class ColorLoopAction : uint8_t
{
    kDeactivate                            = 0x00,
    kActivateFromColorLoopStartEnhancedHue = 0x01,
    kActivateFromEnhancedCurrentHue        = 0x02,
};
#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
using ColorLoopAction                 = EmberAfColorLoopAction;
#endif

// Need to convert consumers to using the new enum classes, so we
// don't just have casts all over.
#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
// Enum for ColorLoopDirection
enum class ColorLoopDirection : uint8_t
{
    kDecrementHue = 0x00,
    kIncrementHue = 0x01,
};
#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
using ColorLoopDirection              = EmberAfColorLoopDirection;
#endif

// Need to convert consumers to using the new enum classes, so we
// don't just have casts all over.
#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
// Enum for ColorMode
enum class ColorMode : uint8_t
{
    kCurrentHueAndCurrentSaturation = 0x00,
    kCurrentXAndCurrentY            = 0x01,
    kColorTemperature               = 0x02,
};
#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
using ColorMode                       = EmberAfColorMode;
#endif

// Need to convert consumers to using the new enum classes, so we
// don't just have casts all over.
#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
// Enum for HueDirection
enum class HueDirection : uint8_t
{
    kShortestDistance = 0x00,
    kLongestDistance  = 0x01,
    kUp               = 0x02,
    kDown             = 0x03,
};
#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
using HueDirection                    = EmberAfHueDirection;
#endif

// Need to convert consumers to using the new enum classes, so we
// don't just have casts all over.
#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
// Enum for HueMoveMode
enum class HueMoveMode : uint8_t
{
    kStop = 0x00,
    kUp   = 0x01,
    kDown = 0x03,
};
#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
using HueMoveMode                     = EmberAfHueMoveMode;
#endif

// Need to convert consumers to using the new enum classes, so we
// don't just have casts all over.
#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
// Enum for HueStepMode
enum class HueStepMode : uint8_t
{
    kUp   = 0x01,
    kDown = 0x03,
};
#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
using HueStepMode                     = EmberAfHueStepMode;
#endif

// Need to convert consumers to using the new enum classes, so we
// don't just have casts all over.
#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
// Enum for SaturationMoveMode
enum class SaturationMoveMode : uint8_t
{
    kStop = 0x00,
    kUp   = 0x01,
    kDown = 0x03,
};
#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
using SaturationMoveMode              = EmberAfSaturationMoveMode;
#endif

// Need to convert consumers to using the new enum classes, so we
// don't just have casts all over.
#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
// Enum for SaturationStepMode
enum class SaturationStepMode : uint8_t
{
    kUp   = 0x01,
    kDown = 0x03,
};
#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
using SaturationStepMode              = EmberAfSaturationStepMode;
#endif

// Bitmap for ColorCapabilities
enum class ColorCapabilities : uint16_t
{
    kHueSaturationSupported    = 0x1,
    kEnhancedHueSupported      = 0x2,
    kColorLoopSupported        = 0x4,
    kXYAttributesSupported     = 0x8,
    kColorTemperatureSupported = 0x10,
};

// Bitmap for ColorLoopUpdateFlags
enum class ColorLoopUpdateFlags : uint8_t
{
    kUpdateAction    = 0x1,
    kUpdateDirection = 0x2,
    kUpdateTime      = 0x4,
    kUpdateStartHue  = 0x8,
};
} // namespace ColorControl

namespace BallastConfiguration {
} // namespace BallastConfiguration

namespace IlluminanceMeasurement {

// Enum for LightSensorType
enum class LightSensorType : uint8_t
{
    kPhotodiode = 0x00,
    kCmos       = 0x01,
};
} // namespace IlluminanceMeasurement

namespace TemperatureMeasurement {
} // namespace TemperatureMeasurement

namespace PressureMeasurement {

// Bitmap for PressureFeature
enum class PressureFeature : uint32_t
{
    kExt = 0x1,
};
} // namespace PressureMeasurement

namespace FlowMeasurement {
} // namespace FlowMeasurement

namespace RelativeHumidityMeasurement {
} // namespace RelativeHumidityMeasurement

namespace OccupancySensing {
} // namespace OccupancySensing

namespace CarbonMonoxideConcentrationMeasurement {
} // namespace CarbonMonoxideConcentrationMeasurement

namespace CarbonDioxideConcentrationMeasurement {
} // namespace CarbonDioxideConcentrationMeasurement

namespace EthyleneConcentrationMeasurement {
} // namespace EthyleneConcentrationMeasurement

namespace EthyleneOxideConcentrationMeasurement {
} // namespace EthyleneOxideConcentrationMeasurement

namespace HydrogenConcentrationMeasurement {
} // namespace HydrogenConcentrationMeasurement

namespace HydrogenSulphideConcentrationMeasurement {
} // namespace HydrogenSulphideConcentrationMeasurement

namespace NitricOxideConcentrationMeasurement {
} // namespace NitricOxideConcentrationMeasurement

namespace NitrogenDioxideConcentrationMeasurement {
} // namespace NitrogenDioxideConcentrationMeasurement

namespace OxygenConcentrationMeasurement {
} // namespace OxygenConcentrationMeasurement

namespace OzoneConcentrationMeasurement {
} // namespace OzoneConcentrationMeasurement

namespace SulfurDioxideConcentrationMeasurement {
} // namespace SulfurDioxideConcentrationMeasurement

namespace DissolvedOxygenConcentrationMeasurement {
} // namespace DissolvedOxygenConcentrationMeasurement

namespace BromateConcentrationMeasurement {
} // namespace BromateConcentrationMeasurement

namespace ChloraminesConcentrationMeasurement {
} // namespace ChloraminesConcentrationMeasurement

namespace ChlorineConcentrationMeasurement {
} // namespace ChlorineConcentrationMeasurement

namespace FecalColiformAndEColiConcentrationMeasurement {
} // namespace FecalColiformAndEColiConcentrationMeasurement

namespace FluorideConcentrationMeasurement {
} // namespace FluorideConcentrationMeasurement

namespace HaloaceticAcidsConcentrationMeasurement {
} // namespace HaloaceticAcidsConcentrationMeasurement

namespace TotalTrihalomethanesConcentrationMeasurement {
} // namespace TotalTrihalomethanesConcentrationMeasurement

namespace TotalColiformBacteriaConcentrationMeasurement {
} // namespace TotalColiformBacteriaConcentrationMeasurement

namespace TurbidityConcentrationMeasurement {
} // namespace TurbidityConcentrationMeasurement

namespace CopperConcentrationMeasurement {
} // namespace CopperConcentrationMeasurement

namespace LeadConcentrationMeasurement {
} // namespace LeadConcentrationMeasurement

namespace ManganeseConcentrationMeasurement {
} // namespace ManganeseConcentrationMeasurement

namespace SulfateConcentrationMeasurement {
} // namespace SulfateConcentrationMeasurement

namespace BromodichloromethaneConcentrationMeasurement {
} // namespace BromodichloromethaneConcentrationMeasurement

namespace BromoformConcentrationMeasurement {
} // namespace BromoformConcentrationMeasurement

namespace ChlorodibromomethaneConcentrationMeasurement {
} // namespace ChlorodibromomethaneConcentrationMeasurement

namespace ChloroformConcentrationMeasurement {
} // namespace ChloroformConcentrationMeasurement

namespace SodiumConcentrationMeasurement {
} // namespace SodiumConcentrationMeasurement

namespace IasZone {

// Need to convert consumers to using the new enum classes, so we
// don't just have casts all over.
#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
// Enum for IasEnrollResponseCode
enum class IasEnrollResponseCode : uint8_t
{
    kSuccess        = 0x00,
    kNotSupported   = 0x01,
    kNoEnrollPermit = 0x02,
    kTooManyZones   = 0x03,
};
#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
using IasEnrollResponseCode           = EmberAfIasEnrollResponseCode;
#endif

// Need to convert consumers to using the new enum classes, so we
// don't just have casts all over.
#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
// Enum for IasZoneType
enum class IasZoneType : uint16_t
{
    kStandardCie             = 0x00,
    kMotionSensor            = 0x0D,
    kContactSwitch           = 0x15,
    kFireSensor              = 0x28,
    kWaterSensor             = 0x2A,
    kGasSensor               = 0x2B,
    kPersonalEmergencyDevice = 0x2C,
    kVibrationMovementSensor = 0x2D,
    kRemoteControl           = 0x10F,
    kKeyFob                  = 0x115,
    kKeypad                  = 0x21D,
    kStandardWarningDevice   = 0x225,
    kGlassBreakSensor        = 0x226,
    kCarbonMonoxideSensor    = 0x227,
    kSecurityRepeater        = 0x229,
    kInvalidZoneType         = 0xFFFF,
};
#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
using IasZoneType                     = EmberAfIasZoneType;
#endif

// Bitmap for IasZoneStatus
enum class IasZoneStatus : uint16_t
{
    kAlarm1             = 0x1,
    kAlarm2             = 0x2,
    kTamper             = 0x4,
    kBattery            = 0x8,
    kSupervisionReports = 0x10,
    kRestoreReports     = 0x20,
    kTrouble            = 0x40,
    kAc                 = 0x80,
    kTest               = 0x100,
    kBatteryDefect      = 0x200,
};
} // namespace IasZone

namespace IasAce {

// Enum for IasAceAlarmStatus
enum class IasAceAlarmStatus : uint8_t
{
    kNoAlarm        = 0x00,
    kBurglar        = 0x01,
    kFire           = 0x02,
    kEmergency      = 0x03,
    kPolicePanic    = 0x04,
    kFirePanic      = 0x05,
    kEmergencyPanic = 0x06,
};

// Enum for IasAceArmMode
enum class IasAceArmMode : uint8_t
{
    kDisarm                 = 0x00,
    kArmDayHomeZonesOnly    = 0x01,
    kArmNightSleepZonesOnly = 0x02,
    kArmAllZones            = 0x03,
};

// Enum for IasAceArmNotification
enum class IasAceArmNotification : uint8_t
{
    kAllZonesDisarmed         = 0x00,
    kOnlyDayHomeZonesArmed    = 0x01,
    kOnlyNightSleepZonesArmed = 0x02,
    kAllZonesArmed            = 0x03,
    kInvalidArmDisarmCode     = 0x04,
    kNotReadyToArm            = 0x05,
    kAlreadyDisarmed          = 0x06,
};

// Enum for IasAceAudibleNotification
enum class IasAceAudibleNotification : uint8_t
{
    kMute         = 0x00,
    kDefaultSound = 0x01,
};

// Enum for IasAceBypassResult
enum class IasAceBypassResult : uint8_t
{
    kZoneBypassed         = 0x00,
    kZoneNotBypassed      = 0x01,
    kNotAllowed           = 0x02,
    kInvalidZoneId        = 0x03,
    kUnknownZoneId        = 0x04,
    kInvalidArmDisarmCode = 0x05,
};

// Enum for IasAcePanelStatus
enum class IasAcePanelStatus : uint8_t
{
    kPanelDisarmed = 0x00,
    kArmedStay     = 0x01,
    kArmedNight    = 0x02,
    kArmedAway     = 0x03,
    kExitDelay     = 0x04,
    kEntryDelay    = 0x05,
    kNotReadyToArm = 0x06,
    kInAlarm       = 0x07,
    kArmingStay    = 0x08,
    kArmingNight   = 0x09,
    kArmingAway    = 0x0A,
};

// Need to convert consumers to using the new enum classes, so we
// don't just have casts all over.
#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
// Enum for IasZoneType
enum class IasZoneType : uint16_t
{
    kStandardCie             = 0x00,
    kMotionSensor            = 0x0D,
    kContactSwitch           = 0x15,
    kFireSensor              = 0x28,
    kWaterSensor             = 0x2A,
    kGasSensor               = 0x2B,
    kPersonalEmergencyDevice = 0x2C,
    kVibrationMovementSensor = 0x2D,
    kRemoteControl           = 0x10F,
    kKeyFob                  = 0x115,
    kKeypad                  = 0x21D,
    kStandardWarningDevice   = 0x225,
    kGlassBreakSensor        = 0x226,
    kCarbonMonoxideSensor    = 0x227,
    kSecurityRepeater        = 0x229,
    kInvalidZoneType         = 0xFFFF,
};
#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
using IasZoneType                     = EmberAfIasZoneType;
#endif

// Bitmap for IasZoneStatus
enum class IasZoneStatus : uint16_t
{
    kAlarm1             = 0x1,
    kAlarm2             = 0x2,
    kTamper             = 0x4,
    kBattery            = 0x8,
    kSupervisionReports = 0x10,
    kRestoreReports     = 0x20,
    kTrouble            = 0x40,
    kAc                 = 0x80,
    kTest               = 0x100,
    kBatteryDefect      = 0x200,
};
} // namespace IasAce

namespace IasWd {

// Bitmap for SquawkInfo
enum class SquawkInfo : uint8_t
{
    kMode   = 0xF0,
    kStrobe = 0x8,
    kLevel  = 0x3,
};

// Bitmap for WarningInfo
enum class WarningInfo : uint8_t
{
    kMode       = 0xF0,
    kStrobe     = 0xC,
    kSirenLevel = 0x3,
};
} // namespace IasWd

namespace WakeOnLan {
} // namespace WakeOnLan

namespace Channel {

// Enum for LineupInfoTypeEnum
enum class LineupInfoTypeEnum : uint8_t
{
    kMso = 0x00,
};

// Enum for StatusEnum
enum class StatusEnum : uint8_t
{
    kSuccess         = 0x00,
    kMultipleMatches = 0x01,
    kNoMatches       = 0x02,
};

// Bitmap for ChannelFeature
enum class ChannelFeature : uint32_t
{
    kChannelList = 0x1,
    kLineupInfo  = 0x2,
};
} // namespace Channel

namespace TargetNavigator {

// Enum for StatusEnum
enum class StatusEnum : uint8_t
{
    kSuccess        = 0x00,
    kTargetNotFound = 0x01,
    kNotAllowed     = 0x02,
};
} // namespace TargetNavigator

namespace MediaPlayback {

// Enum for PlaybackStateEnum
enum class PlaybackStateEnum : uint8_t
{
    kPlaying    = 0x00,
    kPaused     = 0x01,
    kNotPlaying = 0x02,
    kBuffering  = 0x03,
};

// Enum for StatusEnum
enum class StatusEnum : uint8_t
{
    kSuccess                = 0x00,
    kInvalidStateForCommand = 0x01,
    kNotAllowed             = 0x02,
    kNotActive              = 0x03,
    kSpeedOutOfRange        = 0x04,
    kSeekOutOfRange         = 0x05,
};
} // namespace MediaPlayback

namespace MediaInput {

// Enum for InputTypeEnum
enum class InputTypeEnum : uint8_t
{
    kInternal  = 0x00,
    kAux       = 0x01,
    kCoax      = 0x02,
    kComposite = 0x03,
    kHdmi      = 0x04,
    kInput     = 0x05,
    kLine      = 0x06,
    kOptical   = 0x07,
    kVideo     = 0x08,
    kScart     = 0x09,
    kUsb       = 0x0A,
    kOther     = 0x0B,
};

// Bitmap for MediaInputFeature
enum class MediaInputFeature : uint32_t
{
    kNameUpdates = 0x1,
};
} // namespace MediaInput

namespace LowPower {
} // namespace LowPower

namespace KeypadInput {

// Enum for CecKeyCode
enum class CecKeyCode : uint8_t
{
    kSelect                    = 0x00,
    kUp                        = 0x01,
    kDown                      = 0x02,
    kLeft                      = 0x03,
    kRight                     = 0x04,
    kRightUp                   = 0x05,
    kRightDown                 = 0x06,
    kLeftUp                    = 0x07,
    kLeftDown                  = 0x08,
    kRootMenu                  = 0x09,
    kSetupMenu                 = 0x0A,
    kContentsMenu              = 0x0B,
    kFavoriteMenu              = 0x0C,
    kExit                      = 0x0D,
    kMediaTopMenu              = 0x10,
    kMediaContextSensitiveMenu = 0x11,
    kNumberEntryMode           = 0x1D,
    kNumber11                  = 0x1E,
    kNumber12                  = 0x1F,
    kNumber0OrNumber10         = 0x20,
    kNumbers1                  = 0x21,
    kNumbers2                  = 0x22,
    kNumbers3                  = 0x23,
    kNumbers4                  = 0x24,
    kNumbers5                  = 0x25,
    kNumbers6                  = 0x26,
    kNumbers7                  = 0x27,
    kNumbers8                  = 0x28,
    kNumbers9                  = 0x29,
    kDot                       = 0x2A,
    kEnter                     = 0x2B,
    kClear                     = 0x2C,
    kNextFavorite              = 0x2F,
    kChannelUp                 = 0x30,
    kChannelDown               = 0x31,
    kPreviousChannel           = 0x32,
    kSoundSelect               = 0x33,
    kInputSelect               = 0x34,
    kDisplayInformation        = 0x35,
    kHelp                      = 0x36,
    kPageUp                    = 0x37,
    kPageDown                  = 0x38,
    kPower                     = 0x40,
    kVolumeUp                  = 0x41,
    kVolumeDown                = 0x42,
    kMute                      = 0x43,
    kPlay                      = 0x44,
    kStop                      = 0x45,
    kPause                     = 0x46,
    kRecord                    = 0x47,
    kRewind                    = 0x48,
    kFastForward               = 0x49,
    kEject                     = 0x4A,
    kForward                   = 0x4B,
    kBackward                  = 0x4C,
    kStopRecord                = 0x4D,
    kPauseRecord               = 0x4E,
    kReserved                  = 0x4F,
    kAngle                     = 0x50,
    kSubPicture                = 0x51,
    kVideoOnDemand             = 0x52,
    kElectronicProgramGuide    = 0x53,
    kTimerProgramming          = 0x54,
    kInitialConfiguration      = 0x55,
    kSelectBroadcastType       = 0x56,
    kSelectSoundPresentation   = 0x57,
    kPlayFunction              = 0x60,
    kPausePlayFunction         = 0x61,
    kRecordFunction            = 0x62,
    kPauseRecordFunction       = 0x63,
    kStopFunction              = 0x64,
    kMuteFunction              = 0x65,
    kRestoreVolumeFunction     = 0x66,
    kTuneFunction              = 0x67,
    kSelectMediaFunction       = 0x68,
    kSelectAvInputFunction     = 0x69,
    kSelectAudioInputFunction  = 0x6A,
    kPowerToggleFunction       = 0x6B,
    kPowerOffFunction          = 0x6C,
    kPowerOnFunction           = 0x6D,
    kF1Blue                    = 0x71,
    kF2Red                     = 0x72,
    kF3Green                   = 0x73,
    kF4Yellow                  = 0x74,
    kF5                        = 0x75,
    kData                      = 0x76,
};

// Enum for StatusEnum
enum class StatusEnum : uint8_t
{
    kSuccess                  = 0x00,
    kUnsupportedKey           = 0x01,
    kInvalidKeyInCurrentState = 0x02,
};

// Bitmap for KeypadInputFeature
enum class KeypadInputFeature : uint32_t
{
    kNavigationKeyCodes = 0x1,
    kLocationKeys       = 0x2,
    kNumberKeys         = 0x4,
};
} // namespace KeypadInput

namespace ContentLauncher {

// Enum for MetricTypeEnum
enum class MetricTypeEnum : uint8_t
{
    kPixels     = 0x00,
    kPercentage = 0x01,
};

// Enum for ParameterEnum
enum class ParameterEnum : uint8_t
{
    kActor      = 0x00,
    kChannel    = 0x01,
    kCharacter  = 0x02,
    kDirector   = 0x03,
    kEvent      = 0x04,
    kFranchise  = 0x05,
    kGenre      = 0x06,
    kLeague     = 0x07,
    kPopularity = 0x08,
    kProvider   = 0x09,
    kSport      = 0x0A,
    kSportsTeam = 0x0B,
    kType       = 0x0C,
};

// Enum for StatusEnum
enum class StatusEnum : uint8_t
{
    kSuccess         = 0x00,
    kUrlNotAvailable = 0x01,
    kAuthFailed      = 0x02,
};

// Bitmap for ContentLauncherFeature
enum class ContentLauncherFeature : uint32_t
{
    kContentSearch = 0x1,
    kURLPlayback   = 0x2,
};

// Bitmap for SupportedStreamingProtocol
enum class SupportedStreamingProtocol : uint32_t
{
    kDash = 0x1,
    kHls  = 0x2,
};
} // namespace ContentLauncher

namespace AudioOutput {

// Enum for OutputTypeEnum
enum class OutputTypeEnum : uint8_t
{
    kHdmi      = 0x00,
    kBt        = 0x01,
    kOptical   = 0x02,
    kHeadphone = 0x03,
    kInternal  = 0x04,
    kOther     = 0x05,
};

// Bitmap for AudiouOutputFeature
enum class AudiouOutputFeature : uint32_t
{
    kNameUpdates = 0x1,
};
} // namespace AudioOutput

namespace ApplicationLauncher {

// Enum for StatusEnum
enum class StatusEnum : uint8_t
{
    kSuccess         = 0x00,
    kAppNotAvailable = 0x01,
    kSystemBusy      = 0x02,
};

// Bitmap for ApplicationLauncherFeature
enum class ApplicationLauncherFeature : uint32_t
{
    kApplicationPlatform = 0x1,
};
} // namespace ApplicationLauncher

namespace ApplicationBasic {

// Enum for ApplicationStatusEnum
enum class ApplicationStatusEnum : uint8_t
{
    kStopped               = 0x00,
    kActiveVisibleFocus    = 0x01,
    kActiveHidden          = 0x02,
    kActiveVisibleNotFocus = 0x03,
};
} // namespace ApplicationBasic

namespace AccountLogin {
} // namespace AccountLogin

namespace TestCluster {

// Enum for SimpleEnum
enum class SimpleEnum : uint8_t
{
    kUnspecified = 0x00,
    kValueA      = 0x01,
    kValueB      = 0x02,
    kValueC      = 0x03,
};

// Bitmap for Bitmap16MaskMap
enum class Bitmap16MaskMap : uint16_t
{
    kMaskVal1 = 0x1,
    kMaskVal2 = 0x2,
    kMaskVal3 = 0x4,
    kMaskVal4 = 0x4000,
};

// Bitmap for Bitmap32MaskMap
enum class Bitmap32MaskMap : uint32_t
{
    kMaskVal1 = 0x1,
    kMaskVal2 = 0x2,
    kMaskVal3 = 0x4,
    kMaskVal4 = 0x40000000,
};

// Bitmap for Bitmap64MaskMap
enum class Bitmap64MaskMap : uint64_t
{
    kMaskVal1 = 0x1,
    kMaskVal2 = 0x2,
    kMaskVal3 = 0x4,
    kMaskVal4 = 0x4000000000000000,
};

// Bitmap for Bitmap8MaskMap
enum class Bitmap8MaskMap : uint8_t
{
    kMaskVal1 = 0x1,
    kMaskVal2 = 0x2,
    kMaskVal3 = 0x4,
    kMaskVal4 = 0x40,
};

// Bitmap for SimpleBitmap
enum class SimpleBitmap : uint8_t
{
    kValueA = 0x1,
    kValueB = 0x2,
    kValueC = 0x4,
};
} // namespace TestCluster

namespace Messaging {

// Enum for EventId
enum class EventId : uint8_t
{
    kMeterCoverRemoved                  = 0x00,
    kMeterCoverClosed                   = 0x01,
    kStrongMagneticField                = 0x02,
    kNoStrongMagneticField              = 0x03,
    kBatteryFailure                     = 0x04,
    kLowBattery                         = 0x05,
    kProgramMemoryError                 = 0x06,
    kRamError                           = 0x07,
    kNvMemoryError                      = 0x08,
    kMeasurementSystemError             = 0x09,
    kWatchdogError                      = 0x0A,
    kSupplyDisconnectFailure            = 0x0B,
    kSupplyConnectFailure               = 0x0C,
    kMeasurmentSoftwareChanged          = 0x0D,
    kDstEnabled                         = 0x0E,
    kDstDisabled                        = 0x0F,
    kClockAdjBackward                   = 0x10,
    kClockAdjForward                    = 0x11,
    kClockInvalid                       = 0x12,
    kCommsErrorHan                      = 0x13,
    kCommsOkHan                         = 0x14,
    kFraudAttempt                       = 0x15,
    kPowerLoss                          = 0x16,
    kIncorrectProtocol                  = 0x17,
    kUnusualHanTraffic                  = 0x18,
    kUnexpectedClockChange              = 0x19,
    kCommsUsingUnauthenticatedComponent = 0x1A,
    kErrorRegClear                      = 0x1B,
    kAlarmRegClear                      = 0x1C,
    kUnexpectedHwReset                  = 0x1D,
    kUnexpectedProgramExecution         = 0x1E,
    kEventLogCleared                    = 0x1F,
    kManualDisconnect                   = 0x20,
    kManualConnect                      = 0x21,
    kRemoteDisconnection                = 0x22,
    kLocalDisconnection                 = 0x23,
    kLimitThresholdExceeded             = 0x24,
    kLimitThresholdOk                   = 0x25,
    kLimitThresholdChanged              = 0x26,
    kMaximumDemandExceeded              = 0x27,
    kProfileCleared                     = 0x28,
    kFirmwareReadyForActivation         = 0x29,
    kFirmwareActivated                  = 0x2A,
    kPatchFailure                       = 0x2B,
    kTouTariffActivation                = 0x2C,
    k8x8Tariffactivated                 = 0x2D,
    kSingleTariffRateActivated          = 0x2E,
    kAsynchronousBillingOccurred        = 0x2F,
    kSynchronousBillingOccurred         = 0x30,
    kIncorrectPolarity                  = 0x80,
    kCurrentNoVoltage                   = 0x81,
    kUnderVoltage                       = 0x82,
    kOverVoltage                        = 0x83,
    kNormalVoltage                      = 0x84,
    kPfBelowThreshold                   = 0x85,
    kPfAboveThreshold                   = 0x86,
    kTerminalCoverRemoved               = 0x87,
    kTerminalCoverClosed                = 0x88,
    kReverseFlow                        = 0xA0,
    kTiltTamper                         = 0xA1,
    kBatteryCoverRemoved                = 0xA2,
    kBatteryCoverClosed                 = 0xA3,
    kExcessFlow                         = 0xA4,
    kCreditOk                           = 0xC0,
    kLowCredit                          = 0xC1,
    kEmergencyCreditInUse               = 0xC0,
    kEmergencyCreditExhausted           = 0xC1,
    kZeroCreditEcNotSelected            = 0xC2,
    kSupplyOn                           = 0xC3,
    kSupplyOffAarmed                    = 0xC4,
    kSupplyOff                          = 0xC5,
    kDiscountApplied                    = 0xC6,
    kManufacturerSpecificA              = 0xE0,
    kManufacturerSpecificB              = 0xE1,
    kManufacturerSpecificC              = 0xE2,
    kManufacturerSpecificD              = 0xE3,
    kManufacturerSpecificE              = 0xE4,
    kManufacturerSpecificF              = 0xE5,
    kManufacturerSpecificG              = 0xE6,
    kManufacturerSpecificH              = 0xE7,
    kManufacturerSpecificI              = 0xE8,
};

// Enum for MessagingControlConfirmation
enum class MessagingControlConfirmation : uint8_t
{
    kNotRequired = 0x00,
    kRequired    = 0x80,
};

// Enum for MessagingControlEnhancedConfirmation
enum class MessagingControlEnhancedConfirmation : uint8_t
{
    kNotRequired = 0x00,
    kRequired    = 0x20,
};

// Enum for MessagingControlImportance
enum class MessagingControlImportance : uint8_t
{
    kLow      = 0x00,
    kMedium   = 0x04,
    kHigh     = 0x08,
    kCritical = 0x0C,
};

// Enum for MessagingControlTransmission
enum class MessagingControlTransmission : uint8_t
{
    kNormal             = 0x00,
    kNormalAndAnonymous = 0x01,
    kAnonymous          = 0x02,
    kReserved           = 0x03,
};

// Bitmap for MessagingConfirmationControl
enum class MessagingConfirmationControl : uint8_t
{
    kNoReturned  = 0x1,
    kYesReturned = 0x2,
};

// Bitmap for MessagingControlMask
enum class MessagingControlMask : uint8_t
{
    kTransMechanism              = 0x3,
    kMessageUrgency              = 0xC,
    kEnhancedConfirmationRequest = 0x20,
    kMessageConfirmation         = 0x80,
};

// Bitmap for MessagingExtendedControlMask
enum class MessagingExtendedControlMask : uint8_t
{
    kMessageConfirmationStatus = 0x1,
};
} // namespace Messaging

namespace ApplianceIdentification {
} // namespace ApplianceIdentification

namespace MeterIdentification {
} // namespace MeterIdentification

namespace ApplianceEventsAndAlert {

// Enum for EventIdentification
enum class EventIdentification : uint8_t
{
    kEndOfCycle         = 0x01,
    kTemperatureReached = 0x04,
    kEndOfCooking       = 0x05,
    kSwitchingOff       = 0x06,
    kWrongData          = 0x07,
};

// Bitmap for AlertCount
enum class AlertCount : uint8_t
{
    kNumberOfAlerts = 0xF,
    kTypeOfAlert    = 0xF0,
};

// Bitmap for AlertStructure
enum class AlertStructure : uint32_t
{
    kAlertId          = 0xFF,
    kCategory         = 0xF00,
    kPresenceRecovery = 0x3000,
};
} // namespace ApplianceEventsAndAlert

namespace ApplianceStatistics {
} // namespace ApplianceStatistics

namespace ElectricalMeasurement {
} // namespace ElectricalMeasurement

} // namespace Clusters
} // namespace app
} // namespace chip
